# Fichier: python_cheats/cheatsheets/analyse_de_données_projet.txt
# Projets Pratiques d'Analyse de Données - Exercices Réels avec Corrections Détaillées


[OK] INTRODUCTION AUX PROJETS RÉELS

# === POURQUOI DES PROJETS RÉELS? ===

# Les tutoriels utilisent souvent des données parfaites (propres, sans erreurs)
# Dans la vraie vie:
# - Les données sont sales (doublons, erreurs, formats incohérents)
# - Il y a des valeurs manquantes partout
# - Les colonnes ont des noms bizarres
# - Les types de données sont incorrects
# - Il faut prendre des décisions business

# Ces projets te préparent à la RÉALITÉ du travail d'analyste de données


# === STRUCTURE DE CHAQUE PROJET ===

# 1. CONTEXTE BUSINESS
#    -> Comprendre le problème à résoudre
#    -> Qui demande l'analyse? Pourquoi?

# 2. DONNÉES DISPONIBLES
#    -> Description des fichiers
#    -> D'où viennent les données?

# 3. QUESTIONS À RÉPONDRE
#    -> Objectifs précis de l'analyse

# 4. ÉTAPES DE RÉSOLUTION
#    -> Plan d'action détaillé

# 5. CODE COMPLET COMMENTÉ
#    -> Solution pas à pas

# 6. INSIGHTS ET RECOMMANDATIONS
#    -> Ce qu'on découvre et ce qu'on recommande


[OK] PROJET 1: ANALYSE DES VENTES E-COMMERCE

# === CONTEXTE BUSINESS ===

# Tu travailles pour une boutique en ligne "TechStore"
# Le directeur commercial te contacte:
# "Nos ventes stagnent depuis 3 mois. On ne comprend pas pourquoi.
# Peux-tu analyser nos données de ventes et nous dire:
# - Quels produits fonctionnent mal?
# - Y a-t-il des tendances saisonnières?
# - Quelles villes générent le plus de revenus?
# - Faut-il arrêter certains produits?"


# === DONNÉES DISPONIBLES ===

# Fichier: ventes_ecommerce.csv
# Colonnes:
# - order_id: ID commande (ex: ORD-12345)
# - order_date: Date commande (ex: 15/03/2024)
# - customer_id: ID client (ex: CUST-456)
# - customer_city: Ville client (ex: Paris)
# - product_name: Nom produit (ex: Laptop HP 15")
# - product_category: Catégorie (ex: Ordinateurs)
# - quantity: Quantité (ex: 2)
# - unit_price: Prix unitaire (ex: 899.99)
# - discount: Remise % (ex: 10)
# - shipping_cost: Frais livraison (ex: 15.00)

# Problèmes connus dans les données:
# - Dates dans différents formats
# - Villes mal orthographiées (paris, PARIS, Paris)
# - Valeurs manquantes
# - Doublons possibles


# === QUESTIONS À RÉPONDRE ===

# 1. Quel est le chiffre d'affaires total?
# 2. Quels sont les 10 produits les plus vendus?
# 3. Quels sont les 10 produits les moins rentables?
# 4. Quelle est l'évolution des ventes mois par mois?
# 5. Quelles villes génèrent le plus de CA?
# 6. Y a-t-il une corrélation entre remise et quantité vendue?
# 7. Quel est le panier moyen par commande?
# 8. Quels produits devraient être retirés du catalogue?


# === CRÉATION DES DONNÉES DE TEST ===

import pandas as pd
import numpy as np
from datetime import datetime, timedelta
import random

# Générer des données réalistes pour le projet

np.random.seed(42)

# Listes pour générer des données
villes = ['Paris', 'paris', 'PARIS', 'Lyon', 'lyon', 'Marseille', 
          'marseille', 'Toulouse', 'Nice', 'Nantes', 'Bordeaux']

produits = [
    ('Laptop HP 15"', 'Ordinateurs', 899.99),
    ('Laptop Dell 14"', 'Ordinateurs', 749.99),
    ('MacBook Air', 'Ordinateurs', 1299.99),
    ('iPhone 15', 'Smartphones', 999.99),
    ('Samsung Galaxy S24', 'Smartphones', 899.99),
    ('Xiaomi Redmi Note', 'Smartphones', 299.99),
    ('Souris Logitech', 'Accessoires', 29.99),
    ('Clavier Mécanique', 'Accessoires', 89.99),
    ('Écran 24"', 'Moniteurs', 199.99),
    ('Écran 27"', 'Moniteurs', 299.99),
    ('Webcam HD', 'Accessoires', 49.99),
    ('Casque Audio', 'Accessoires', 79.99),
    ('Tablette Samsung', 'Tablettes', 349.99),
    ('iPad Pro', 'Tablettes', 899.99),
    ('Imprimante HP', 'Imprimantes', 149.99)
]

# Générer 5000 lignes de ventes sur 12 mois
n_rows = 5000
start_date = datetime(2023, 1, 1)

data = []

for i in range(n_rows):
    order_id = f"ORD-{10000 + i}"
    
    # Date aléatoire sur 12 mois
    days_offset = random.randint(0, 365)
    order_date = start_date + timedelta(days=days_offset)
    
    # Format de date aléatoire (pour simuler l'incohérence)
    if random.random() < 0.3:
        order_date_str = order_date.strftime('%d/%m/%Y')
    elif random.random() < 0.6:
        order_date_str = order_date.strftime('%Y-%m-%d')
    else:
        order_date_str = order_date.strftime('%m-%d-%Y')
    
    customer_id = f"CUST-{random.randint(100, 2000)}"
    customer_city = random.choice(villes)
    
    # Produit aléatoire
    product = random.choice(produits)
    product_name = product[0]
    product_category = product[1]
    unit_price = product[2]
    
    # Quantité (certains produits se vendent mieux)
    if 'Accessoires' in product_category:
        quantity = random.randint(1, 5)
    else:
        quantity = random.randint(1, 2)
    
    # Remise aléatoire
    discount = random.choice([0, 5, 10, 15, 20])
    
    # Frais de livraison
    if unit_price * quantity > 500:
        shipping_cost = 0  # Livraison gratuite
    else:
        shipping_cost = round(random.uniform(5, 20), 2)
    
    # Ajouter des valeurs manquantes aléatoirement (10% de chance)
    if random.random() < 0.1:
        customer_city = np.nan
    
    if random.random() < 0.05:
        discount = np.nan
    
    data.append([
        order_id, order_date_str, customer_id, customer_city,
        product_name, product_category, quantity, unit_price,
        discount, shipping_cost
    ])

# Créer le DataFrame
df = pd.DataFrame(data, columns=[
    'order_id', 'order_date', 'customer_id', 'customer_city',
    'product_name', 'product_category', 'quantity', 'unit_price',
    'discount', 'shipping_cost'
])

# Ajouter des doublons (2% de chance)
duplicates = df.sample(frac=0.02)
df = pd.concat([df, duplicates], ignore_index=True)

# Sauvegarder
df.to_csv('ventes_ecommerce.csv', index=False)

print(f"[OK] Fichier créé: ventes_ecommerce.csv ({len(df)} lignes)")


# === SOLUTION COMPLÈTE PAS À PAS ===

# === ÉTAPE 1: IMPORTER LES BIBLIOTHÈQUES ===

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from datetime import datetime

# Configuration graphiques
plt.style.use('seaborn-v0_8-darkgrid')
sns.set_palette("husl")

print("[OK] Bibliothèques importées")


# === ÉTAPE 2: CHARGER LES DONNÉES ===

df = pd.read_csv('ventes_ecommerce.csv')

print(f"[GRAPHIQUE] Données chargées: {len(df)} lignes, {len(df.columns)} colonnes")
print("\n=== Aperçu des données ===")
print(df.head())


# === ÉTAPE 3: EXPLORER LES DONNÉES ===

print("\n=== Informations générales ===")
print(df.info())

print("\n=== Statistiques descriptives ===")
print(df.describe())

print("\n=== Valeurs manquantes ===")
print(df.isnull().sum())

print("\n=== Valeurs uniques par colonne ===")
for col in df.columns:
    print(f"{col}: {df[col].nunique()} valeurs uniques")


# === ÉTAPE 4: NETTOYER LES DONNÉES ===

print("\n" + "="*50)
print("[NETTOYAGE] NETTOYAGE DES DONNÉES")
print("="*50)

# 4.1 Supprimer les doublons
print(f"\n[IMPORTANT] Doublons détectés: {df.duplicated().sum()}")
df = df.drop_duplicates()
print(f"[OK] Après suppression: {len(df)} lignes")

# 4.2 Nettoyer les noms de villes (uniformiser)
print("\n[IMPORTANT] Nettoyage des villes...")
print("Avant:")
print(df['customer_city'].value_counts())

df['customer_city'] = df['customer_city'].str.strip()
df['customer_city'] = df['customer_city'].str.title()

print("\nAprès:")
print(df['customer_city'].value_counts())

# 4.3 Convertir les dates (gérer les formats multiples)
print("\n[IMPORTANT] Conversion des dates...")

def parse_date(date_str):
    """
    Essaie plusieurs formats de date
    """
    if pd.isna(date_str):
        return np.nan
    
    formats = ['%d/%m/%Y', '%Y-%m-%d', '%m-%d-%Y']
    
    for fmt in formats:
        try:
            return pd.to_datetime(date_str, format=fmt)
        except:
            continue
    
    return np.nan

df['order_date'] = df['order_date'].apply(parse_date)

print(f"[OK] Dates converties: {df['order_date'].notna().sum()} / {len(df)}")

# 4.4 Gérer les valeurs manquantes

print(f"\n[IMPORTANT] Valeurs manquantes dans 'customer_city': {df['customer_city'].isna().sum()}")
# On supprime ces lignes (pas de ville = commande invalide)
df = df.dropna(subset=['customer_city'])

print(f"\n[IMPORTANT] Valeurs manquantes dans 'discount': {df['discount'].isna().sum()}")
# Remplacer NaN par 0 (pas de remise)
df['discount'] = df['discount'].fillna(0)

print(f"[OK] Données nettoyées: {len(df)} lignes restantes")


# === ÉTAPE 5: CRÉER LES COLONNES CALCULÉES ===

print("\n" + "="*50)
print("[NOMBRE] CRÉATION DES COLONNES CALCULÉES")
print("="*50)

# 5.1 Prix après remise
df['discounted_price'] = df['unit_price'] * (1 - df['discount'] / 100)

# 5.2 Chiffre d'affaires (CA)
df['revenue'] = df['discounted_price'] * df['quantity']

# 5.3 Chiffre d'affaires total (avec frais de livraison)
df['total_revenue'] = df['revenue'] + df['shipping_cost']

# 5.4 Extraire le mois et l'année
df['month'] = df['order_date'].dt.month
df['year'] = df['order_date'].dt.year
df['month_name'] = df['order_date'].dt.month_name()

# 5.5 Marge (simulée: on suppose 30% de marge sur le prix)
df['cost'] = df['unit_price'] * 0.7
df['profit'] = df['revenue'] - (df['cost'] * df['quantity'])

print("[OK] Colonnes calculées créées:")
print(df[['unit_price', 'discount', 'discounted_price', 'revenue', 'profit']].head())


# === ÉTAPE 6: ANALYSE - QUESTION 1 ===

print("\n" + "="*50)
print("[?] QUESTION 1: Quel est le CA total?")
print("="*50)

ca_total = df['revenue'].sum()
ca_total_shipping = df['total_revenue'].sum()
profit_total = df['profit'].sum()

print(f"\n[ARGENT] Chiffre d'affaires (produits): {ca_total:,.2f} €")
print(f"[ARGENT] Chiffre d'affaires (avec livraison): {ca_total_shipping:,.2f} €")
print(f"[ARGENT] Profit total: {profit_total:,.2f} €")
print(f"[GRAPHIQUE] Marge moyenne: {(profit_total / ca_total * 100):.2f}%")


# === ÉTAPE 7: ANALYSE - QUESTION 2 ===

print("\n" + "="*50)
print("[?] QUESTION 2: Top 10 produits les plus vendus")
print("="*50)

top_products = df.groupby('product_name').agg({
    'quantity': 'sum',
    'revenue': 'sum',
    'order_id': 'count'
}).rename(columns={'order_id': 'nb_commandes'})

top_products = top_products.sort_values('quantity', ascending=False).head(10)

print("\n[GRAPHIQUE] Top 10 produits par quantité:")
print(top_products)

# Visualisation
plt.figure(figsize=(12, 6))
top_products['quantity'].plot(kind='barh', color='skyblue')
plt.title('Top 10 Produits les Plus Vendus (Quantité)', fontsize=14, fontweight='bold')
plt.xlabel('Quantité vendue')
plt.ylabel('Produit')
plt.tight_layout()
plt.savefig('top10_produits.png', dpi=300, bbox_inches='tight')
plt.show()

print("\n[OK] Graphique sauvegardé: top10_produits.png")


# === ÉTAPE 8: ANALYSE - QUESTION 3 ===

print("\n" + "="*50)
print("[?] QUESTION 3: Top 10 produits les MOINS rentables")
print("="*50)

products_profit = df.groupby('product_name').agg({
    'profit': 'sum',
    'revenue': 'sum',
    'quantity': 'sum'
})

products_profit['marge_%'] = (products_profit['profit'] / products_profit['revenue'] * 100)
products_profit = products_profit.sort_values('profit', ascending=True).head(10)

print("\n[GRAPHIQUE] Top 10 produits les moins rentables:")
print(products_profit)

# Visualisation
plt.figure(figsize=(12, 6))
products_profit['profit'].plot(kind='barh', color='salmon')
plt.title('Top 10 Produits les Moins Rentables', fontsize=14, fontweight='bold')
plt.xlabel('Profit (€)')
plt.ylabel('Produit')
plt.axvline(x=0, color='red', linestyle='--', linewidth=1)
plt.tight_layout()
plt.savefig('bottom10_produits.png', dpi=300, bbox_inches='tight')
plt.show()

print("\n[OK] Graphique sauvegardé: bottom10_produits.png")


# === ÉTAPE 9: ANALYSE - QUESTION 4 ===

print("\n" + "="*50)
print("[?] QUESTION 4: Évolution des ventes mois par mois")
print("="*50)

# Grouper par année et mois
monthly_sales = df.groupby(['year', 'month']).agg({
    'revenue': 'sum',
    'order_id': 'count',
    'quantity': 'sum'
}).rename(columns={'order_id': 'nb_commandes'})

print("\n[GRAPHIQUE] Ventes mensuelles:")
print(monthly_sales)

# Créer une colonne de date pour le graphique
df['year_month'] = df['order_date'].dt.to_period('M')
monthly_trend = df.groupby('year_month')['revenue'].sum()

# Visualisation
plt.figure(figsize=(14, 6))
monthly_trend.plot(kind='line', marker='o', color='green', linewidth=2)
plt.title('Évolution du Chiffre d\'Affaires Mensuel', fontsize=14, fontweight='bold')
plt.xlabel('Mois')
plt.ylabel('CA (€)')
plt.xticks(rotation=45)
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('evolution_mensuelle.png', dpi=300, bbox_inches='tight')
plt.show()

print("\n[OK] Graphique sauvegardé: evolution_mensuelle.png")

# Analyse de tendance
print("\n[HAUSSE] Analyse de tendance:")
print(f"Meilleur mois: {monthly_trend.idxmax()} avec {monthly_trend.max():,.2f} €")
print(f"Pire mois: {monthly_trend.idxmin()} avec {monthly_trend.min():,.2f} €")

# Variation mensuelle moyenne
variation = monthly_trend.pct_change().mean() * 100
print(f"Variation moyenne mois par mois: {variation:.2f}%")


# === ÉTAPE 10: ANALYSE - QUESTION 5 ===

print("\n" + "="*50)
print("[?] QUESTION 5: Quelles villes génèrent le plus de CA?")
print("="*50)

city_sales = df.groupby('customer_city').agg({
    'revenue': 'sum',
    'order_id': 'count',
    'customer_id': 'nunique'
}).rename(columns={
    'order_id': 'nb_commandes',
    'customer_id': 'nb_clients'
})

city_sales = city_sales.sort_values('revenue', ascending=False)

print("\n[GRAPHIQUE] CA par ville:")
print(city_sales)

# Visualisation
plt.figure(figsize=(12, 6))
city_sales['revenue'].plot(kind='bar', color='purple')
plt.title('Chiffre d\'Affaires par Ville', fontsize=14, fontweight='bold')
plt.xlabel('Ville')
plt.ylabel('CA (€)')
plt.xticks(rotation=45)
plt.tight_layout()
plt.savefig('ca_par_ville.png', dpi=300, bbox_inches='tight')
plt.show()

print("\n[OK] Graphique sauvegardé: ca_par_ville.png")


# === ÉTAPE 11: ANALYSE - QUESTION 6 ===

print("\n" + "="*50)
print("[?] QUESTION 6: Corrélation entre remise et quantité")
print("="*50)

# Calculer la corrélation
correlation = df[['discount', 'quantity', 'revenue']].corr()

print("\n[GRAPHIQUE] Matrice de corrélation:")
print(correlation)

# Visualisation
plt.figure(figsize=(8, 6))
sns.heatmap(correlation, annot=True, cmap='coolwarm', center=0, 
            square=True, linewidths=1)
plt.title('Corrélation: Remise vs Quantité vs CA', fontsize=14, fontweight='bold')
plt.tight_layout()
plt.savefig('correlation.png', dpi=300, bbox_inches='tight')
plt.show()

print("\n[OK] Graphique sauvegardé: correlation.png")

# Analyse par tranche de remise
discount_analysis = df.groupby('discount').agg({
    'quantity': 'mean',
    'revenue': 'mean',
    'order_id': 'count'
})

print("\n[GRAPHIQUE] Analyse par tranche de remise:")
print(discount_analysis)


# === ÉTAPE 12: ANALYSE - QUESTION 7 ===

print("\n" + "="*50)
print("[?] QUESTION 7: Panier moyen par commande")
print("="*50)

order_summary = df.groupby('order_id').agg({
    'revenue': 'sum',
    'quantity': 'sum',
    'product_name': 'count'
}).rename(columns={'product_name': 'nb_items'})

panier_moyen = order_summary['revenue'].mean()
quantite_moyenne = order_summary['quantity'].mean()
items_moyen = order_summary['nb_items'].mean()

print(f"\n[GRAPHIQUE] Panier moyen: {panier_moyen:.2f} €")
print(f"[PACKAGE] Quantité moyenne par commande: {quantite_moyenne:.2f} articles")
print(f"[SHOPPING_TROLLEY] Nombre d'items moyen: {items_moyen:.2f} produits différents")

# Distribution des paniers
plt.figure(figsize=(12, 5))

plt.subplot(1, 2, 1)
order_summary['revenue'].hist(bins=50, color='teal', edgecolor='black')
plt.title('Distribution des Paniers (CA)', fontweight='bold')
plt.xlabel('Montant (€)')
plt.ylabel('Fréquence')

plt.subplot(1, 2, 2)
order_summary['quantity'].hist(bins=30, color='orange', edgecolor='black')
plt.title('Distribution des Quantités', fontweight='bold')
plt.xlabel('Quantité')
plt.ylabel('Fréquence')

plt.tight_layout()
plt.savefig('distribution_paniers.png', dpi=300, bbox_inches='tight')
plt.show()

print("\n[OK] Graphique sauvegardé: distribution_paniers.png")


# === ÉTAPE 13: ANALYSE - QUESTION 8 ===

print("\n" + "="*50)
print("[?] QUESTION 8: Produits à retirer du catalogue?")
print("="*50)

# Critères pour retirer un produit:
# 1. Faible volume de ventes (< 50 unités)
# 2. Marge négative ou très faible (< 5%)
# 3. Peu de commandes (< 20 commandes)

product_analysis = df.groupby('product_name').agg({
    'quantity': 'sum',
    'revenue': 'sum',
    'profit': 'sum',
    'order_id': 'count'
}).rename(columns={'order_id': 'nb_commandes'})

product_analysis['marge_%'] = (product_analysis['profit'] / product_analysis['revenue'] * 100)

# Identifier les produits à retirer
products_to_remove = product_analysis[
    (product_analysis['quantity'] < 50) |
    (product_analysis['marge_%'] < 5) |
    (product_analysis['nb_commandes'] < 20)
]

print("\n[ATTENTION] Produits à considérer pour retrait:")
print(products_to_remove)

if len(products_to_remove) > 0:
    plt.figure(figsize=(12, 6))
    products_to_remove['marge_%'].plot(kind='barh', color='red')
    plt.title('Produits à Faible Performance (Marge %)', fontsize=14, fontweight='bold')
    plt.xlabel('Marge (%)')
    plt.ylabel('Produit')
    plt.axvline(x=5, color='orange', linestyle='--', linewidth=2, label='Seuil: 5%')
    plt.legend()
    plt.tight_layout()
    plt.savefig('produits_a_retirer.png', dpi=300, bbox_inches='tight')
    plt.show()
    
    print("\n[OK] Graphique sauvegardé: produits_a_retirer.png")
else:
    print("\n[OK] Aucun produit ne répond aux critères de retrait")


# === ÉTAPE 14: INSIGHTS ET RECOMMANDATIONS ===

print("\n" + "="*50)
print("[IDEE] INSIGHTS ET RECOMMANDATIONS BUSINESS")
print("="*50)

print("\n[RECHERCHE] INSIGHTS CLÉS:")
print("-" * 50)

# Insight 1: Performance globale
print(f"\n1⃣ PERFORMANCE GLOBALE")
print(f"   • CA total: {ca_total:,.2f} €")
print(f"   • Profit total: {profit_total:,.2f} €")
print(f"   • Marge moyenne: {(profit_total / ca_total * 100):.2f}%")
print(f"   • Nombre de commandes: {df['order_id'].nunique():,}")

# Insight 2: Produits
best_product = top_products.index[0]
worst_product = products_profit.index[0]
print(f"\n2⃣ PRODUITS")
print(f"   • Meilleur produit: {best_product}")
print(f"   • Pire produit: {worst_product}")
print(f"   • Produits à retirer: {len(products_to_remove)}")

# Insight 3: Géographie
best_city = city_sales.index[0]
print(f"\n3⃣ GÉOGRAPHIE")
print(f"   • Meilleure ville: {best_city} ({city_sales.loc[best_city, 'revenue']:,.2f} €)")
print(f"   • Top 3 villes: {', '.join(city_sales.head(3).index.tolist())}")

# Insight 4: Tendances temporelles
print(f"\n4⃣ TENDANCES TEMPORELLES")
print(f"   • Meilleur mois: {monthly_trend.idxmax()}")
print(f"   • Variation moyenne: {variation:.2f}%")

# Insight 5: Remises
avg_discount = df['discount'].mean()
high_discount_sales = df[df['discount'] >= 15]['revenue'].sum()
low_discount_sales = df[df['discount'] < 15]['revenue'].sum()

print(f"\n5⃣ STRATÉGIE DE REMISE")
print(f"   • Remise moyenne: {avg_discount:.1f}%")
print(f"   • CA avec remise élevée (≥15%): {high_discount_sales:,.2f} €")
print(f"   • CA avec remise faible (<15%): {low_discount_sales:,.2f} €")

print("\n\n[LISTE] RECOMMANDATIONS:")
print("-" * 50)

print("\n[OK] 1. OPTIMISATION DU CATALOGUE")
if len(products_to_remove) > 0:
    print(f"   • Retirer {len(products_to_remove)} produits peu rentables")
    print(f"   • Économie potentielle: {-products_to_remove['profit'].sum():,.2f} €")
else:
    print("   • Le catalogue est bien optimisé")

print("\n[OK] 2. FOCUS GÉOGRAPHIQUE")
top_3_cities = city_sales.head(3)
print(f"   • Concentrer les efforts marketing sur: {', '.join(top_3_cities.index)}")
print(f"   • Ces villes représentent {(top_3_cities['revenue'].sum() / ca_total * 100):.1f}% du CA")

print("\n[OK] 3. STRATÉGIE PRIX/REMISE")
if correlation.loc['discount', 'quantity'] > 0.2:
    print("   • Les remises augmentent significativement les ventes")
    print("   • Recommandation: Augmenter les remises sur produits à forte marge")
else:
    print("   • Les remises n'ont pas d'impact fort sur les ventes")
    print("   • Recommandation: Réduire les remises pour préserver la marge")

print("\n[OK] 4. SAISONNALITÉ")
print(f"   • Renforcer le stock avant {monthly_trend.idxmax()}")
print(f"   • Préparer des promotions pour {monthly_trend.idxmin()}")


# === ÉTAPE 15: EXPORT DES RÉSULTATS ===

print("\n" + "="*50)
print("[SAUVEGARDE] EXPORT DES RÉSULTATS")
print("="*50)

# Créer un rapport Excel avec plusieurs feuilles
with pd.ExcelWriter('rapport_analyse_ventes.xlsx', engine='openpyxl') as writer:
    # Feuille 1: Résumé global
    summary = pd.DataFrame({
        'Métrique': ['CA Total', 'Profit Total', 'Marge %', 'Nb Commandes', 'Panier Moyen'],
        'Valeur': [
            f"{ca_total:,.2f} €",
            f"{profit_total:,.2f} €",
            f"{(profit_total / ca_total * 100):.2f}%",
            df['order_id'].nunique(),
            f"{panier_moyen:.2f} €"
        ]
    })
    summary.to_excel(writer, sheet_name='Résumé', index=False)
    
    # Feuille 2: Top produits
    top_products.to_excel(writer, sheet_name='Top_Produits')
    
    # Feuille 3: Produits à retirer
    if len(products_to_remove) > 0:
        products_to_remove.to_excel(writer, sheet_name='Produits_à_Retirer')
    
    # Feuille 4: CA par ville
    city_sales.to_excel(writer, sheet_name='CA_par_Ville')
    
    # Feuille 5: Évolution mensuelle
    monthly_sales.to_excel(writer, sheet_name='Évolution_Mensuelle')

print("[OK] Rapport Excel créé: rapport_analyse_ventes.xlsx")

# Sauvegarder les données nettoyées
df.to_csv('ventes_ecommerce_clean.csv', index=False)
print("[OK] Données nettoyées sauvegardées: ventes_ecommerce_clean.csv")

print("\n[BRAVO] ANALYSE TERMINÉE!")


[OK] PROJET 2: ANALYSE RH - TURNOVER EMPLOYÉS

# === CONTEXTE BUSINESS ===

# Tu travailles au département RH d'une entreprise "TechCorp" (500 employés)
# La directrice RH est inquiète:
# "Nous avons un taux de départ élevé (turnover). 
# Peux-tu analyser les données pour comprendre POURQUOI les employés partent?
# Qui risque de partir prochainement?
# Que devons-nous faire pour les retenir?"


# === DONNÉES DISPONIBLES ===

# Fichier: employees_hr.csv
# Colonnes:
# - employee_id: ID employé
# - name: Nom
# - department: Département (IT, Sales, HR, Finance, Marketing)
# - position: Poste
# - hire_date: Date d'embauche
# - salary: Salaire annuel (€)
# - performance_rating: Note performance (1-5)
# - satisfaction_score: Score satisfaction (0-100)
# - projects_count: Nombre de projets
# - avg_monthly_hours: Heures mensuelles moyennes
# - time_since_promotion: Mois depuis dernière promotion
# - has_left: 1 si parti, 0 sinon


# === CRÉATION DES DONNÉES ===

np.random.seed(42)

n_employees = 500

departments = ['IT', 'Sales', 'HR', 'Finance', 'Marketing']
positions = {
    'IT': ['Developer', 'Senior Developer', 'Tech Lead', 'Manager'],
    'Sales': ['Sales Rep', 'Senior Sales', 'Sales Manager'],
    'HR': ['HR Specialist', 'HR Manager'],
    'Finance': ['Accountant', 'Finance Analyst', 'CFO'],
    'Marketing': ['Marketing Specialist', 'Marketing Manager']
}

data = []

for i in range(n_employees):
    employee_id = f"EMP-{1000 + i}"
    name = f"Employee_{i}"
    department = random.choice(departments)
    position = random.choice(positions[department])
    
    # Date d'embauche (entre 0 et 10 ans)
    years_in_company = random.uniform(0, 10)
    hire_date = datetime.now() - timedelta(days=int(years_in_company * 365))
    
    # Salaire (dépend du département et poste)
    base_salary = {
        'IT': 45000,
        'Sales': 40000,
        'HR': 35000,
        'Finance': 42000,
        'Marketing': 38000
    }
    
    if 'Manager' in position or 'Lead' in position:
        salary = base_salary[department] * random.uniform(1.5, 2.0)
    elif 'Senior' in position:
        salary = base_salary[department] * random.uniform(1.2, 1.5)
    else:
        salary = base_salary[department] * random.uniform(0.9, 1.2)
    
    salary = round(salary, 2)
    
    # Performance (1-5)
    performance_rating = random.randint(1, 5)
    
    # Satisfaction (0-100)
    # Les gens insatisfaits partent plus
    if random.random() < 0.3:  # 30% insatisfaits
        satisfaction_score = random.randint(20, 50)
    else:
        satisfaction_score = random.randint(60, 95)
    
    # Projets
    projects_count = random.randint(2, 10)
    
    # Heures
    avg_monthly_hours = random.randint(140, 240)
    
    # Promotion
    time_since_promotion = random.randint(0, 60)
    
    # Départ (plus probable si insatisfait, surcharge, pas de promo)
    leave_probability = 0.1  # Base 10%
    
    if satisfaction_score < 50:
        leave_probability += 0.3
    if avg_monthly_hours > 200:
        leave_probability += 0.2
    if time_since_promotion > 36:
        leave_probability += 0.2
    if performance_rating <= 2:
        leave_probability += 0.15
    
    has_left = 1 if random.random() < leave_probability else 0
    
    data.append([
        employee_id, name, department, position,
        hire_date.strftime('%Y-%m-%d'), salary,
        performance_rating, satisfaction_score, projects_count,
        avg_monthly_hours, time_since_promotion, has_left
    ])

df_hr = pd.DataFrame(data, columns=[
    'employee_id', 'name', 'department', 'position',
    'hire_date', 'salary', 'performance_rating',
    'satisfaction_score', 'projects_count', 'avg_monthly_hours',
    'time_since_promotion', 'has_left'
])

df_hr.to_csv('employees_hr.csv', index=False)

print(f"[OK] Fichier créé: employees_hr.csv ({len(df_hr)} lignes)")


# === SOLUTION COMPLÈTE ===

print("\n" + "="*70)
print("[ENTREPRISE] PROJET 2: ANALYSE RH - TURNOVER EMPLOYÉS")
print("="*70)

# Charger les données
df_hr = pd.read_csv('employees_hr.csv')

print(f"\n[GRAPHIQUE] Données chargées: {len(df_hr)} employés")
print("\n=== Aperçu ===")
print(df_hr.head())


# === NETTOYAGE ===

print("\n[NETTOYAGE] NETTOYAGE")
print("-" * 50)

# Convertir la date
df_hr['hire_date'] = pd.to_datetime(df_hr['hire_date'])

# Calculer l'ancienneté
df_hr['tenure_years'] = (datetime.now() - df_hr['hire_date']).dt.days / 365

print("[OK] Données nettoyées")


# === ANALYSE GLOBALE ===

print("\n[GRAPHIQUE] ANALYSE GLOBALE DU TURNOVER")
print("-" * 50)

total_employees = len(df_hr)
left_employees = df_hr['has_left'].sum()
turnover_rate = (left_employees / total_employees) * 100

print(f"\n• Effectif total: {total_employees}")
print(f"• Employés partis: {left_employees}")
print(f"• Taux de turnover: {turnover_rate:.1f}%")

# Turnover par département
dept_turnover = df_hr.groupby('department').agg({
    'has_left': ['sum', 'count']
})
dept_turnover.columns = ['Partis', 'Total']
dept_turnover['Taux_%'] = (dept_turnover['Partis'] / dept_turnover['Total'] * 100)
dept_turnover = dept_turnover.sort_values('Taux_%', ascending=False)

print("\n[GRAPHIQUE] Turnover par département:")
print(dept_turnover)

# Visualisation
plt.figure(figsize=(10, 6))
dept_turnover['Taux_%'].plot(kind='bar', color='coral')
plt.title('Taux de Turnover par Département', fontsize=14, fontweight='bold')
plt.xlabel('Département')
plt.ylabel('Taux de turnover (%)')
plt.xticks(rotation=45)
plt.axhline(y=turnover_rate, color='red', linestyle='--', label=f'Moyenne: {turnover_rate:.1f}%')
plt.legend()
plt.tight_layout()
plt.savefig('turnover_departement.png', dpi=300)
plt.show()


# === ANALYSE DES FACTEURS ===

print("\n[RECHERCHE] ANALYSE DES FACTEURS DE DÉPART")
print("-" * 50)

# Comparer les employés partis vs restés
comparison = df_hr.groupby('has_left').agg({
    'satisfaction_score': 'mean',
    'salary': 'mean',
    'avg_monthly_hours': 'mean',
    'time_since_promotion': 'mean',
    'performance_rating': 'mean',
    'projects_count': 'mean'
}).round(2)

comparison.index = ['Restés', 'Partis']

print("\n[GRAPHIQUE] Comparaison Restés vs Partis:")
print(comparison)

# Visualisation
fig, axes = plt.subplots(2, 3, figsize=(15, 10))
fig.suptitle('Comparaison: Employés Restés vs Partis', fontsize=16, fontweight='bold')

metrics = ['satisfaction_score', 'salary', 'avg_monthly_hours', 
           'time_since_promotion', 'performance_rating', 'projects_count']
titles = ['Satisfaction', 'Salaire (€)', 'Heures mensuelles',
          'Mois depuis promotion', 'Performance', 'Nb projets']

for idx, (metric, title) in enumerate(zip(metrics, titles)):
    ax = axes[idx // 3, idx % 3]
    df_hr.boxplot(column=metric, by='has_left', ax=ax)
    ax.set_title(title)
    ax.set_xlabel('0=Resté, 1=Parti')
    plt.sca(ax)
    plt.xticks([1, 2], ['Restés', 'Partis'])

plt.tight_layout()
plt.savefig('comparaison_facteurs.png', dpi=300)
plt.show()


# === IDENTIFICATION DES EMPLOYÉS À RISQUE ===

print("\n[ATTENTION] IDENTIFICATION DES EMPLOYÉS À RISQUE")
print("-" * 50)

# Critères de risque (seulement pour ceux qui ne sont PAS encore partis)
df_active = df_hr[df_hr['has_left'] == 0].copy()

df_active['risk_score'] = 0

# Ajouter des points de risque
df_active.loc[df_active['satisfaction_score'] < 50, 'risk_score'] += 3
df_active.loc[df_active['avg_monthly_hours'] > 200, 'risk_score'] += 2
df_active.loc[df_active['time_since_promotion'] > 36, 'risk_score'] += 2
df_active.loc[df_active['performance_rating'] >= 4, 'risk_score'] += 1  # Bons performers insatisfaits = risque
df_active.loc[df_active['tenure_years'] < 2, 'risk_score'] += 1

# Catégoriser le risque
df_active['risk_category'] = pd.cut(
    df_active['risk_score'],
    bins=[-1, 2, 4, 10],
    labels=['Faible', 'Moyen', 'Élevé']
)

risk_summary = df_active['risk_category'].value_counts()

print("\n[GRAPHIQUE] Répartition des risques:")
print(risk_summary)

# Top 20 employés à risque élevé
high_risk = df_active[df_active['risk_category'] == 'Élevé'].sort_values('risk_score', ascending=False)

print(f"\n[ATTENTION] {len(high_risk)} employés à risque ÉLEVÉ de départ:")
print(high_risk[['employee_id', 'name', 'department', 'position', 
                 'satisfaction_score', 'risk_score']].head(20))


# === CORRÉLATIONS ===

print("\n[GRAPHIQUE] CORRÉLATIONS AVEC LE DÉPART")
print("-" * 50)

correlation_df = df_hr[[
    'has_left', 'satisfaction_score', 'salary', 'avg_monthly_hours',
    'time_since_promotion', 'performance_rating', 'projects_count'
]].corr()

print("\nCorrélations avec 'has_left':")
print(correlation_df['has_left'].sort_values(ascending=False))

# Heatmap
plt.figure(figsize=(10, 8))
sns.heatmap(correlation_df, annot=True, cmap='RdYlGn', center=0, 
            square=True, linewidths=1)
plt.title('Matrice de Corrélation - Facteurs de Turnover', fontsize=14, fontweight='bold')
plt.tight_layout()
plt.savefig('correlation_turnover.png', dpi=300)
plt.show()


# === RECOMMANDATIONS ===

print("\n[IDEE] INSIGHTS ET RECOMMANDATIONS")
print("="*70)

print("\n[RECHERCHE] INSIGHTS CLÉS:")
print("-" * 50)

print(f"\n1⃣ AMPLEUR DU PROBLÈME")
print(f"   • Taux de turnover global: {turnover_rate:.1f}%")
worst_dept = dept_turnover.index[0]
print(f"   • Département le plus touché: {worst_dept} ({dept_turnover.loc[worst_dept, 'Taux_%']:.1f}%)")
print(f"   • Coût estimé: {left_employees * 50000:,} € (50k€ par départ)")

print(f"\n2⃣ FACTEURS PRINCIPAUX")
sat_diff = comparison.loc['Restés', 'satisfaction_score'] - comparison.loc['Partis', 'satisfaction_score']
hours_diff = comparison.loc['Partis', 'avg_monthly_hours'] - comparison.loc['Restés', 'avg_monthly_hours']
promo_diff = comparison.loc['Partis', 'time_since_promotion'] - comparison.loc['Restés', 'time_since_promotion']

print(f"   • Satisfaction: -{sat_diff:.0f} points pour ceux qui partent")
print(f"   • Heures de travail: +{hours_diff:.0f}h/mois pour ceux qui partent")
print(f"   • Promotion: +{promo_diff:.0f} mois sans promotion")

print(f"\n3⃣ EMPLOYÉS À RISQUE")
print(f"   • {len(high_risk)} employés à risque élevé")
print(f"   • Action immédiate nécessaire sur ces profils")

print("\n\n[LISTE] RECOMMANDATIONS PRIORITAIRES:")
print("-" * 50)

print("\n[OK] 1. ACTIONS IMMÉDIATES (0-3 mois)")
print(f"   • Rencontrer les {len(high_risk)} employés à risque élevé")
print(f"   • Focus sur {worst_dept}: taux critique de {dept_turnover.loc[worst_dept, 'Taux_%']:.1f}%")
print("   • Sondage de satisfaction approfondi")

print("\n[OK] 2. ÉQUILIBRE VIE PRO/PERSO (3-6 mois)")
print(f"   • Réduire les heures des employés >200h/mois")
print("   • Politique de télétravail renforcée")
print("   • Programme de bien-être au travail")

print("\n[OK] 3. GESTION DES CARRIÈRES (6-12 mois)")
print(f"   • Revoir les promotions: moyenne actuelle {comparison.loc['Partis', 'time_since_promotion']:.0f} mois")
print("   • Créer des plans de carrière clairs")
print("   • Programme de mentoring")

print("\n[OK] 4. RECONNAISSANCE (En continu)")
print("   • Programme de reconnaissance mensuel")
print("   • Révision salariale pour hautes performances")
print("   • Bonus projets")


# === EXPORT ===

with pd.ExcelWriter('rapport_turnover_hr.xlsx') as writer:
    # Résumé
    summary_hr = pd.DataFrame({
        'Métrique': ['Effectif', 'Départs', 'Taux Turnover (%)', 'Coût Estimé (€)'],
        'Valeur': [total_employees, left_employees, f"{turnover_rate:.1f}", f"{left_employees * 50000:,}"]
    })
    summary_hr.to_excel(writer, sheet_name='Résumé', index=False)
    
    # Turnover par département
    dept_turnover.to_excel(writer, sheet_name='Turnover_Dept')
    
    # Employés à risque
    high_risk.to_excel(writer, sheet_name='Employés_Risque', index=False)
    
    # Comparaison
    comparison.to_excel(writer, sheet_name='Comparaison')

print("\n[OK] Rapport Excel créé: rapport_turnover_hr.xlsx")
print("\n[BRAVO] ANALYSE TERMINÉE!")


[OK] PROJET 3: ANALYSE DE DONNÉES CLIENTS - SEGMENTATION

# === CONTEXTE BUSINESS ===

# Tu travailles pour une plateforme de streaming "StreamFlix"
# Le CMO (Chief Marketing Officer) te demande:
# "Nous avons 50,000 abonnés mais tous ne se comportent pas pareil.
# Peux-tu segmenter nos clients en groupes homogènes?
# Cela nous aidera à personnaliser nos campagnes marketing."


# === DONNÉES DISPONIBLES ===

# Fichier: customers_streaming.csv
# Colonnes:
# - customer_id: ID client
# - subscription_date: Date d'abonnement
# - subscription_type: Type (Basic, Standard, Premium)
# - monthly_price: Prix mensuel
# - age: Âge
# - country: Pays
# - devices_count: Nombre d'appareils
# - hours_watched: Heures visionnées (mensuel)
# - content_type: Type de contenu préféré
# - last_login: Date dernière connexion
# - is_churned: 1 si désabonné, 0 sinon


# === CRÉATION DES DONNÉES ===

np.random.seed(42)

n_customers = 5000

subscription_types = ['Basic', 'Standard', 'Premium']
countries = ['France', 'Belgium', 'Switzerland', 'Canada']
content_types = ['Movies', 'Series', 'Documentaries', 'Kids']

data = []

for i in range(n_customers):
    customer_id = f"CUST-{10000 + i}"
    
    # Date d'abonnement (0-5 ans)
    days_subscribed = random.randint(0, 1825)
    subscription_date = datetime.now() - timedelta(days=days_subscribed)
    
    # Type d'abonnement
    sub_type = random.choice(subscription_types)
    monthly_price = {
        'Basic': 9.99,
        'Standard': 13.99,
        'Premium': 17.99
    }[sub_type]
    
    # Âge
    age = random.randint(18, 70)
    
    # Pays
    country = random.choice(countries)
    
    # Appareils
    devices_count = random.randint(1, 5)
    
    # Heures visionnées (varie selon type)
    if sub_type == 'Premium':
        hours_watched = random.randint(40, 150)
    elif sub_type == 'Standard':
        hours_watched = random.randint(20, 80)
    else:
        hours_watched = random.randint(5, 40)
    
    # Type de contenu
    content_type = random.choice(content_types)
    
    # Dernière connexion
    days_since_login = random.randint(0, 60)
    last_login = datetime.now() - timedelta(days=days_since_login)
    
    # Churn (plus probable si peu d'heures, type Basic, pas connecté récemment)
    churn_prob = 0.05
    if hours_watched < 20:
        churn_prob += 0.2
    if sub_type == 'Basic':
        churn_prob += 0.1
    if days_since_login > 30:
        churn_prob += 0.15
    
    is_churned = 1 if random.random() < churn_prob else 0
    
    data.append([
        customer_id, subscription_date.strftime('%Y-%m-%d'),
        sub_type, monthly_price, age, country, devices_count,
        hours_watched, content_type, last_login.strftime('%Y-%m-%d'),
        is_churned
    ])

df_customers = pd.DataFrame(data, columns=[
    'customer_id', 'subscription_date', 'subscription_type',
    'monthly_price', 'age', 'country', 'devices_count',
    'hours_watched', 'content_type', 'last_login', 'is_churned'
])

df_customers.to_csv('customers_streaming.csv', index=False)

print(f"[OK] Fichier créé: customers_streaming.csv ({len(df_customers)} lignes)")


# === SOLUTION COMPLÈTE ===

print("\n" + "="*70)
print("[TELEVISION] PROJET 3: SEGMENTATION CLIENTS STREAMING")
print("="*70)

from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans
from sklearn.decomposition import PCA

# Charger
df_customers = pd.read_csv('customers_streaming.csv')

print(f"\n[GRAPHIQUE] Données: {len(df_customers)} clients")
print(df_customers.head())


# === PRÉPARATION ===

print("\n[OUTIL] PRÉPARATION DES DONNÉES")
print("-" * 50)

# Convertir les dates
df_customers['subscription_date'] = pd.to_datetime(df_customers['subscription_date'])
df_customers['last_login'] = pd.to_datetime(df_customers['last_login'])

# Calculer l'ancienneté
df_customers['tenure_days'] = (datetime.now() - df_customers['subscription_date']).dt.days

# Jours depuis dernière connexion
df_customers['days_since_login'] = (datetime.now() - df_customers['last_login']).dt.days

# Revenu total (ancienneté × prix)
df_customers['total_revenue'] = (df_customers['tenure_days'] / 30) * df_customers['monthly_price']

print("[OK] Variables calculées créées")


# === ANALYSE DESCRIPTIVE ===

print("\n[GRAPHIQUE] ANALYSE DESCRIPTIVE")
print("-" * 50)

print("\n• Répartition par type d'abonnement:")
print(df_customers['subscription_type'].value_counts())

print("\n• Statistiques d'utilisation:")
print(df_customers[['hours_watched', 'devices_count', 'age', 'tenure_days']].describe())

churn_rate = df_customers['is_churned'].mean() * 100
print(f"\n• Taux de churn: {churn_rate:.1f}%")


# === SEGMENTATION K-MEANS ===

print("\n[OBJECTIF] SEGMENTATION PAR K-MEANS")
print("-" * 50)

# Sélectionner les variables pour la segmentation
features = ['age', 'hours_watched', 'devices_count', 'tenure_days', 
            'monthly_price', 'days_since_login']

X = df_customers[features].copy()

# Normaliser
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Méthode du coude pour trouver le nombre optimal de clusters
inertias = []
K_range = range(2, 11)

for k in K_range:
    kmeans = KMeans(n_clusters=k, random_state=42, n_init=10)
    kmeans.fit(X_scaled)
    inertias.append(kmeans.inertia_)

# Visualiser
plt.figure(figsize=(10, 6))
plt.plot(K_range, inertias, marker='o', linewidth=2)
plt.title('Méthode du Coude - Nombre Optimal de Clusters', fontsize=14, fontweight='bold')
plt.xlabel('Nombre de clusters')
plt.ylabel('Inertie')
plt.xticks(K_range)
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('elbow_method.png', dpi=300)
plt.show()

# Choisir k=4 (supposons que c'est le coude)
optimal_k = 4
kmeans = KMeans(n_clusters=optimal_k, random_state=42, n_init=10)
df_customers['segment'] = kmeans.fit_predict(X_scaled)

print(f"\n[OK] Segmentation en {optimal_k} clusters effectuée")
print("\nRépartition des clients:")
print(df_customers['segment'].value_counts().sort_index())


# === PROFIL DES SEGMENTS ===

print("\n[GRAPHIQUE] PROFIL DES SEGMENTS")
print("-" * 50)

segment_profiles = df_customers.groupby('segment').agg({
    'age': 'mean',
    'hours_watched': 'mean',
    'devices_count': 'mean',
    'tenure_days': 'mean',
    'monthly_price': 'mean',
    'days_since_login': 'mean',
    'is_churned': 'mean',
    'customer_id': 'count'
}).round(2)

segment_profiles.columns = ['Âge Moyen', 'Heures/mois', 'Appareils', 
                            'Ancienneté (jours)', 'Prix', 'Dernière Co (jours)',
                            'Taux Churn', 'Nb Clients']

print(segment_profiles)

# Nommer les segments
segment_names = {
    0: 'Occasionnels',
    1: 'Fidèles Actifs',
    2: 'Nouveaux Explorateurs',
    3: 'À Risque'
}

# Ajuster selon les caractéristiques réelles
# (à affiner manuellement selon les résultats)

df_customers['segment_name'] = df_customers['segment'].map(segment_names)


# === VISUALISATION DES SEGMENTS ===

print("\n[GRAPHIQUE] VISUALISATION DES SEGMENTS")
print("-" * 50)

# Réduction de dimensionnalité avec PCA pour visualiser
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X_scaled)

df_customers['PC1'] = X_pca[:, 0]
df_customers['PC2'] = X_pca[:, 1]

plt.figure(figsize=(12, 8))
for segment in range(optimal_k):
    mask = df_customers['segment'] == segment
    plt.scatter(df_customers.loc[mask, 'PC1'], 
               df_customers.loc[mask, 'PC2'],
               label=f'Segment {segment}',
               alpha=0.6, s=50)

plt.title('Visualisation des Segments Clients (PCA)', fontsize=14, fontweight='bold')
plt.xlabel(f'PC1 ({pca.explained_variance_ratio_[0]*100:.1f}% variance)')
plt.ylabel(f'PC2 ({pca.explained_variance_ratio_[1]*100:.1f}% variance)')
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('segments_visualization.png', dpi=300)
plt.show()


# === ANALYSE PAR SEGMENT ===

print("\n[RECHERCHE] ANALYSE DÉTAILLÉE PAR SEGMENT")
print("-" * 50)

for segment in range(optimal_k):
    seg_data = df_customers[df_customers['segment'] == segment]
    
    print(f"\n{'='*50}")
    print(f"SEGMENT {segment}: {segment_names.get(segment, f'Segment {segment}')}")
    print(f"{'='*50}")
    
    print(f"\n• Taille: {len(seg_data)} clients ({len(seg_data)/len(df_customers)*100:.1f}%)")
    print(f"• Âge moyen: {seg_data['age'].mean():.0f} ans")
    print(f"• Heures visionnées: {seg_data['hours_watched'].mean():.0f}h/mois")
    print(f"• Ancienneté: {seg_data['tenure_days'].mean():.0f} jours")
    print(f"• Taux de churn: {seg_data['is_churned'].mean()*100:.1f}%")
    print(f"• Type d'abonnement le plus fréquent: {seg_data['subscription_type'].mode()[0]}")
    print(f"• Contenu préféré: {seg_data['content_type'].mode()[0]}")
    print(f"• Revenu moyen généré: {seg_data['total_revenue'].mean():.2f} €")


# === RECOMMANDATIONS PAR SEGMENT ===

print("\n[IDEE] STRATÉGIES MARKETING PAR SEGMENT")
print("="*70)

recommendations = {
    0: {
        'nom': 'Occasionnels',
        'caractéristiques': 'Peu d\'heures, usage irrégulier',
        'actions': [
            '[EMAIL] Emails avec recommandations personnalisées',
            '[WRAPPED_PRESENT] Offrir 1 mois gratuit pour upgrade',
            '[TELEVISION] Push notifications contenu populaire'
        ]
    },
    1: {
        'nom': 'Fidèles Actifs',
        'caractéristiques': 'Forte utilisation, anciens clients',
        'actions': [
            '* Programme de fidélité VIP',
            '[DEMARRAGE] Accès prioritaire aux nouveautés',
            '[SPEECH_BALLOON] Solliciter avis et témoignages'
        ]
    },
    2: {
        'nom': 'Nouveaux Explorateurs',
        'caractéristiques': 'Récents, utilisation moyenne',
        'actions': [
            '[WAVING_HAND_SIGN] Onboarding renforcé (guide, tutoriels)',
            '[MOBILE] Encourager multi-devices',
            '[OBJECTIF] Recommandations basées sur premiers visionnages'
        ]
    },
    3: {
        'nom': 'À Risque',
        'caractéristiques': 'Peu connectés, risque de churn élevé',
        'actions': [
            '[ATTENTION] Campagne de réengagement urgente',
            '[ARGENT]Réduction tarifaire temporaire',
            '[TEL] Appel téléphonique personnalisé'
        ]
    }
}

for segment, info in recommendations.items():
    print(f"\n{'='*50}")
    print(f"SEGMENT {segment}: {info['nom'].upper()}")
    print(f"{'='*50}")
    print(f"\n[NOTE] Caractéristiques: {info['caractéristiques']}")
    print("\n[OBJECTIF] Actions recommandées:")
    for action in info['actions']:
        print(f"   {action}")


# === EXPORT ===

with pd.ExcelWriter('rapport_segmentation_clients.xlsx') as writer:
    # Profils segments
    segment_profiles.to_excel(writer, sheet_name='Profils_Segments')
    
    # Liste clients par segment
    for segment in range(optimal_k):
        seg_data = df_customers[df_customers['segment'] == segment][[
            'customer_id', 'age', 'subscription_type', 'hours_watched',
            'tenure_days', 'is_churned'
        ]]
        seg_data.to_excel(writer, sheet_name=f'Segment_{segment}', index=False)

print("\n[OK] Rapport Excel créé: rapport_segmentation_clients.xlsx")
print("\n[BRAVO] ANALYSE TERMINÉE!")


[OK] PROJET 4: ANALYSE FINANCIÈRE - PRÉVISION DE VENTES

# === CONTEXTE BUSINESS ===

# Tu travailles pour une chaîne de magasins "RetailMax"
# Le CFO te demande:
# "Nous devons prévoir nos ventes pour les 6 prochains mois.
# Peux-tu analyser l'historique et créer un modèle de prévision?
# Nous avons besoin de chiffres fiables pour notre budget."


# === DONNÉES DISPONIBLES ===

# Fichier: sales_history.csv
# Colonnes:
# - date: Date
# - store_id: ID magasin
# - sales: Ventes (€)
# - customers: Nombre de clients
# - promotions: 1 si promo, 0 sinon
# - weather: Météo (Sunny, Rainy, Cloudy)
# - holiday: 1 si jour férié, 0 sinon


# === CRÉATION DES DONNÉES ===

np.random.seed(42)

# Générer 2 ans de données journalières pour 5 magasins
start_date = datetime(2022, 1, 1)
end_date = datetime(2023, 12, 31)
dates = pd.date_range(start=start_date, end=end_date, freq='D')

stores = ['STORE-1', 'STORE-2', 'STORE-3', 'STORE-4', 'STORE-5']
weathers = ['Sunny', 'Rainy', 'Cloudy']

data = []

for store in stores:
    base_sales = random.uniform(5000, 15000)  # Ventes de base par magasin
    
    for date in dates:
        # Tendance croissante
        days_from_start = (date - start_date).days
        trend = days_from_start * random.uniform(2, 5)
        
        # Saisonnalité (pic en décembre, creux en août)
        month = date.month
        if month == 12:
            seasonality = 1.5
        elif month in [7, 8]:
            seasonality = 0.7
        else:
            seasonality = 1.0
        
        # Effet jour de la semaine
        weekday = date.weekday()
        if weekday >= 5:  # Weekend
            weekday_effect = 1.3
        else:
            weekday_effect = 1.0
        
        # Promo (20% de chance)
        has_promo = 1 if random.random() < 0.2 else 0
        promo_effect = 1.4 if has_promo else 1.0
        
        # Météo
        weather = random.choice(weathers)
        weather_effect = {
            'Sunny': 1.1,
            'Rainy': 0.9,
            'Cloudy': 1.0
        }[weather]
        
        # Jour férié (5% de chance)
        is_holiday = 1 if random.random() < 0.05 else 0
        holiday_effect = 0.6 if is_holiday else 1.0
        
        # Calcul des ventes
        sales = (base_sales + trend) * seasonality * weekday_effect * promo_effect * weather_effect * holiday_effect
        sales = sales * random.uniform(0.9, 1.1)  # Bruit aléatoire
        sales = round(sales, 2)
        
        # Nombre de clients (corrélé avec ventes)
        customers = int(sales / random.uniform(40, 60))
        
        data.append([
            date.strftime('%Y-%m-%d'), store, sales, customers,
            has_promo, weather, is_holiday
        ])

df_sales = pd.DataFrame(data, columns=[
    'date', 'store_id', 'sales', 'customers',
    'promotions', 'weather', 'holiday'
])

df_sales.to_csv('sales_history.csv', index=False)

print(f"[OK] Fichier créé: sales_history.csv ({len(df_sales)} lignes)")


# === SOLUTION COMPLÈTE ===

print("\n" + "="*70)
print("[ARGENT] PROJET 4: PRÉVISION DES VENTES")
print("="*70)

from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score

# Charger
df_sales = pd.read_csv('sales_history.csv')
df_sales['date'] = pd.to_datetime(df_sales['date'])

print(f"\n[GRAPHIQUE] Historique: {len(df_sales)} lignes")
print(df_sales.head())


# === ANALYSE EXPLORATOIRE ===

print("\n[GRAPHIQUE] ANALYSE EXPLORATOIRE")
print("-" * 50)

# Statistiques globales
print(f"\n• Période: {df_sales['date'].min()} à {df_sales['date'].max()}")
print(f"• Ventes totales: {df_sales['sales'].sum():,.2f} €")
print(f"• Ventes moyennes quotidiennes: {df_sales['sales'].mean():,.2f} €")
print(f"• Nombre de magasins: {df_sales['store_id'].nunique()}")

# Évolution temporelle
df_sales['year_month'] = df_sales['date'].dt.to_period('M')
monthly_sales = df_sales.groupby('year_month')['sales'].sum()

plt.figure(figsize=(14, 6))
monthly_sales.plot(kind='line', marker='o', linewidth=2, color='darkgreen')
plt.title('Évolution des Ventes Mensuelles', fontsize=14, fontweight='bold')
plt.xlabel('Mois')
plt.ylabel('Ventes (€)')
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('evolution_ventes.png', dpi=300)
plt.show()


# === FEATURE ENGINEERING ===

print("\n[OUTIL] FEATURE ENGINEERING")
print("-" * 50)

df_sales['year'] = df_sales['date'].dt.year
df_sales['month'] = df_sales['date'].dt.month
df_sales['day'] = df_sales['date'].dt.day
df_sales['weekday'] = df_sales['date'].dt.weekday
df_sales['is_weekend'] = (df_sales['weekday'] >= 5).astype(int)
df_sales['quarter'] = df_sales['date'].dt.quarter

# Encoder la météo
df_sales = pd.get_dummies(df_sales, columns=['weather'], prefix='weather')

# Calculer des moyennes mobiles
df_sales = df_sales.sort_values(['store_id', 'date'])
df_sales['sales_MA7'] = df_sales.groupby('store_id')['sales'].transform(
    lambda x: x.rolling(window=7, min_periods=1).mean()
)
df_sales['sales_MA30'] = df_sales.groupby('store_id')['sales'].transform(
    lambda x: x.rolling(window=30, min_periods=1).mean()
)

print("[OK] Features créées")


# === MODÈLE DE PRÉVISION ===

print("\n[BOT] MODÈLE DE PRÉVISION")
print("-" * 50)

# Préparer les données
features = ['month', 'weekday', 'is_weekend', 'promotions', 'holiday', 
            'weather_Cloudy', 'weather_Rainy', 'weather_Sunny',
            'sales_MA7', 'sales_MA30', 'customers']

X = df_sales[features]
y = df_sales['sales']

# Split train/test (80/20)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, shuffle=False
)

print(f"• Train: {len(X_train)} lignes")
print(f"• Test: {len(X_test)} lignes")

# Entraîner le modèle
model = RandomForestRegressor(n_estimators=100, random_state=42, n_jobs=-1)
model.fit(X_train, y_train)

print("[OK] Modèle entraîné")

# Prédictions
y_pred = model.predict(X_test)

# Métriques
mae = mean_absolute_error(y_test, y_pred)
rmse = np.sqrt(mean_squared_error(y_test, y_pred))
r2 = r2_score(y_test, y_pred)

print(f"\n[GRAPHIQUE] Performance du modèle:")
print(f"   • MAE: {mae:,.2f} €")
print(f"   • RMSE: {rmse:,.2f} €")
print(f"   • R²: {r2:.3f}")


# === VISUALISATION DES PRÉDICTIONS ===

results = pd.DataFrame({
    'Réel': y_test.values,
    'Prédit': y_pred
})

plt.figure(figsize=(14, 6))
plt.plot(results['Réel'].values[:100], label='Ventes Réelles', linewidth=2)
plt.plot(results['Prédit'].values[:100], label='Ventes Prédites', linewidth=2, linestyle='--')
plt.title('Comparaison: Ventes Réelles vs Prédites (100 premiers jours)', fontsize=14, fontweight='bold')
plt.xlabel('Jour')
plt.ylabel('Ventes (€)')
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('predictions_vs_reel.png', dpi=300)
plt.show()


# === IMPORTANCE DES FEATURES ===

feature_importance = pd.DataFrame({
    'feature': features,
    'importance': model.feature_importances_
}).sort_values('importance', ascending=False)

print("\n[GRAPHIQUE] Importance des variables:")
print(feature_importance)

plt.figure(figsize=(10, 6))
feature_importance.plot(x='feature', y='importance', kind='barh', legend=False, color='steelblue')
plt.title('Importance des Variables dans les Prévisions', fontsize=14, fontweight='bold')
plt.xlabel('Importance')
plt.tight_layout()
plt.savefig('feature_importance.png', dpi=300)
plt.show()


# === PRÉVISIONS FUTURES ===

print("\n[CRYSTAL_BALL] PRÉVISIONS POUR LES 6 PROCHAINS MOIS")
print("-" * 50)

# Générer les dates futures
last_date = df_sales['date'].max()
future_dates = pd.date_range(start=last_date + timedelta(days=1), periods=180, freq='D')

# Pour simplifier, on fait des prévisions pour un magasin
store = 'STORE-1'
last_data = df_sales[df_sales['store_id'] == store].iloc[-1]

future_data = []

for date in future_dates:
    # Supposer des conditions moyennes
    row = {
        'month': date.month,
        'weekday': date.weekday(),
        'is_weekend': 1 if date.weekday() >= 5 else 0,
        'promotions': 0,  # Pas de promo par défaut
        'holiday': 0,
        'weather_Cloudy': 1 if random.random() < 0.3 else 0,
        'weather_Rainy': 1 if random.random() < 0.3 else 0,
        'weather_Sunny': 1 if random.random() < 0.4 else 0,
        'sales_MA7': last_data['sales_MA7'],
        'sales_MA30': last_data['sales_MA30'],
        'customers': int(last_data['customers'])
    }
    
    future_data.append(row)

df_future = pd.DataFrame(future_data)

# Prédire
future_predictions = model.predict(df_future)

# Résultats
forecast_df = pd.DataFrame({
    'Date': future_dates,
    'Ventes_Prédites': future_predictions
})

forecast_df['Mois'] = forecast_df['Date'].dt.to_period('M')
monthly_forecast = forecast_df.groupby('Mois')['Ventes_Prédites'].sum()

print("\n[GRAPHIQUE] Prévisions mensuelles (Magasin STORE-1):")
print(monthly_forecast)

plt.figure(figsize=(12, 6))
monthly_forecast.plot(kind='bar', color='darkblue')
plt.title('Prévisions de Ventes - 6 Prochains Mois', fontsize=14, fontweight='bold')
plt.xlabel('Mois')
plt.ylabel('Ventes (€)')
plt.xticks(rotation=45)
plt.tight_layout()
plt.savefig('previsions_6_mois.png', dpi=300)
plt.show()


# === RECOMMANDATIONS ===

print("\n[IDEE] RECOMMANDATIONS BUSINESS")
print("="*70)

total_forecast = forecast_df['Ventes_Prédites'].sum()
avg_monthly_forecast = monthly_forecast.mean()

print(f"\n[GRAPHIQUE] PRÉVISIONS GLOBALES:")
print(f"   • Total 6 mois: {total_forecast:,.2f} €")
print(f"   • Moyenne mensuelle: {avg_monthly_forecast:,.2f} €")

print(f"\n[OK] RECOMMANDATIONS:")
print(f"   1. Budget: Prévoir {total_forecast:,.2f} € de revenus")
print(f"   2. Stock: Ajuster selon la prévision mensuelle")
print(f"   3. Promotions: Planifier sur les mois prévus plus faibles")
print(f"   4. Personnel: Renforcer sur les mois de pic")

# Export
forecast_df.to_csv('previsions_ventes_6mois.csv', index=False)
print("\n[OK] Prévisions exportées: previsions_ventes_6mois.csv")

print("\n[BRAVO] ANALYSE TERMINÉE!")


[OK] BONNES PRATIQUES ANALYSE DE DONNÉES

# === CHECKLIST PROJET D'ANALYSE ===

"""
[ ] 1. COMPRENDRE LE CONTEXTE BUSINESS
   - Qui demande l'analyse?
   - Pourquoi?
   - Quelles décisions seront prises?

[ ] 2. EXPLORER LES DONNÉES
   - df.head(), df.info(), df.describe()
   - Identifier les types de données
   - Repérer les valeurs manquantes

[ ] 3. NETTOYER LES DONNÉES
   - Supprimer les doublons
   - Gérer les valeurs manquantes
   - Corriger les types de données
   - Uniformiser les formats

[ ] 4. CRÉER DES FEATURES
   - Variables calculées
   - Agrégations
   - Encodage des catégories

[ ] 5. ANALYSER
   - Statistiques descriptives
   - Corrélations
   - Visualisations

[ ] 6. INTERPRÉTER
   - Quels patterns?
   - Quelles anomalies?
   - Répondre aux questions business

[ ] 7. RECOMMANDER
   - Actions concrètes
   - Quantifier l'impact
   - Prioriser

[ ] 8. COMMUNIQUER
   - Rapport clair
   - Graphiques lisibles
   - Langage business (pas technique)

[ ] 9. EXPORTER
   - Fichiers Excel
   - CSV nettoyés
   - Graphiques HD

[ ] 10. DOCUMENTER
   - Code commenté
   - README
   - Méthodologie
"""


[OK] RESSOURCES POUR ALLER PLUS LOIN

# === DATASETS RÉELS GRATUITS ===

# Kaggle: https://www.kaggle.com/datasets
# - Millions de datasets réels
# - Compétitions pour pratiquer

# UCI Machine Learning: https://archive.ics.uci.edu/ml
# - Datasets académiques classiques

# Data.gouv.fr: https://www.data.gouv.fr
# - Données publiques françaises

# Google Dataset Search: https://datasetsearch.research.google.com
# - Moteur de recherche de datasets


# === LIVRES RECOMMANDÉS ===

# "Python for Data Analysis" - Wes McKinney (créateur de Pandas)
# "Hands-On Machine Learning" - Aurélien Géron
# "Data Science from Scratch" - Joel Grus


# === COURS EN LIGNE ===

# DataCamp: https://www.datacamp.com
# Coursera: https://www.coursera.org
# freeCodeCamp: https://www.freecodecamp.org


# === COMMUNAUTÉS ===

# Reddit: r/datascience, r/learnpython
# Stack Overflow: https://stackoverflow.com
# Kaggle Forums: https://www.kaggle.com/discussion


print("\n[BRAVO] FIN DES PROJETS D'ANALYSE DE DONNÉES!")
print("\n[FORCE] Continue à pratiquer avec de vrais datasets!")
print("[RAPIDE] La pratique est la clé de la maîtrise!")
```

Voilà le fichier complet `python_cheats/cheatsheets/analyse_de_données_projet.txt` ! [BRAVO]

Ce guide contient **4 projets complets et réalistes** d'analyse de données avec :
- **Contexte business** clair
- **Données réelles** (simulées mais réalistes)
- **Code complet** commenté pas à pas
- **Visualisations** professionnelles
- **Insights** et recommandations business
- **Export** des résultats

Chaque projet couvre un cas d'usage différent :
1. [SHOPPING_TROLLEY] E-commerce (ventes)
2. [UTILISATEURS] RH (turnover)
3. [TELEVISION] Clients (segmentation)
4. [ARGENT] Finance (prévisions)